Bridging the gap between design and implementation of components libraries

Object-oriented design is usually driven by three main reusability principles: step-by-step design, design for reuse and design with reuse. However, these principles are just partially applied to the subsequent object-oriented implementation, often due to efficienc y constraints, yielding to a gap between design and implementation. In this paper we provide a solution for bridging this gap for a concrete framework, the one of designing and implementing container-like component libraries, such as STL, Booc h Components, etc. Our approach is based on a new design pattern together with its corresponding implementation. The proposal enhances the same principles that drive the design process: step-by--step implementation (adding just what is needed in every step), implementation with reuse (component implementations are reused while library implementation progresses and component hierarchies grow) and implementation for reuse (intermediate component implementations can be reused in many different points o f the hierarchy). We use our approach in two different manners: for building a brand-new container-like component library, and for reengineering an existing one, Booch Components in Ada95.Postprint (published version

Improving design and implementation of OO container-like component libraries

Object-oriented design is usually driven by three main reusability principles: step-by-step design, design for reuse and design with reuse. However, these principles tend to be just partially applied to the subsequent object-oriented implementation, often because they conflict with other quality criteria (remarkably, efficiency). So, there is a gap between design and implementation: due to these conflicts developers use to give up design level abstractions during the implementation. In this paper we present a framework for bridging this gap for a concrete domain, the design and implementation of object-oriented container-like component libraries, such as JCF, STL, Booch Components, LEDA, etc. At the core of the framework we propose a new design pattern called emph{Shortcut} together with its corresponding implementation. The Shortcut pattern, introduced in a generic base class container, provides a secure and efficient access to items in a container decoupled from the implementation details of concrete containers. Shortcut enhances applying the same principles that drive the design process to the implementation process of these libraries: step-by-step implementation, implementation with reuse and implementation for reuse without penalising other quality criteria. Our framework not only supports the design and implementation of new libraries but also the reengineering of existing ones to overcome some of their drawbacks. We show by a case study, reengineering the Booch Components in Ada95, the application and benefits of our framework.Postprint (published version

Adding efficient and reliable access paths to the JCF

The Java Collections Framework (JCF) is the standard Java library for representing and manipulating collections (i.e., objects that represent a group of objects, such as sets, lists, etc.). Although JCF provides adequate functionality for many purposes, it does not offer any mechanism for accessing directly the objects stored in collections apart from the standard Java references. This absence is a crucial functionality exhibited by many other widespread Java and non-Java collection libraries. In this paper, we carry out a reengineering process on the JCF to add this kind of alternative access paths, which we give the name of shortcuts. This process relies on a framework called Shortcut-Based Framework, which has been defined as library- independent. We present this framework and then we show how it may be tailored to the specific case of the JCF. The resulting JCF with shortcuts library is fully compatible with the original one (i.e., programs using the original JCF are not required to be modified), and exhibits good behaviour with respect to efficiency, reliability and internal quality. As an additional benefit of the framework, we mention that it can be applied to other collection libraries, as we have done before with an Ada95 one.Postprint (published version

Shortcuts: abstract "pointers''

In this work we present the specification and the implementation of a new abstract data type (ADT) called STORE. This new ADT allows the storage of a given collection of elements offering an abstract mechanism that supplies a direct access to them, alternative to the method defined by the standard operations of usual ADTs. The interest of the new mechanism stems from the efficiency of pointers, while avoiding the loss of modularity that usually occurs when pointers are used. The implementation of the operations offered by the new ADT is done by derivation from the equational specification. The representation chosen for the implementation of the new ADT makes the efficiency previously mentioned possible, even when the representation strategy requires the movement of the elements.Postprint (published version

Reconciliando modularidad y eficiencia mediante atajos

Se presenta en este artículo una propuesta para el desarrollo de programas eficientes en el marco de la programación con tipos abstractos de datos (TAD), con el objetivo de respetar la estructura modular de los programas propia de este ámbito. La propuesta se centra en el concepto de atajo como camino eficiente de acceso a los datos, alternativo al acceso mediante las operaciones propias del TAD, y se desarrolla sobre un TAD concreto, el almacén de elementos. La definición de los atajos es altamente formal, mediante especificaciones algebraicas interpretadas con semántica inicial, de manera que el resultado tiene un significado bien definido y encaja sin problemas en el marco de la programación con TAD. La eficiencia se asegura mediante una implementación adecuada del tipo, que proporciona acceso constante a los datos siguiendo los atajos sin penalizar las otras operaciones del TAD. Se ilustra la utilidad de la propuesta mediante un ejemplo concreto.Peer ReviewedPostprint (author's final draft

Reengineering the booch component library

Component-based software development heavily relies on the ability of reusing components from a library with as little effort as possible. Among others, valuable features for reusing from a component library are: adaptability to many contexts, extensibility, abstraction and high level of robustness with respect to changes in some of their components. In this paper we study one of the most widely used component library for Ada 95, the Grady Booch’s one, mainly in relation to these features. Our study focuses on the Container-classes family, which present some drawbacks mainly due to the fact that some parent-classes depend on the concrete form of their children-classes. We propose a solution centred on changing the Containers base class. This new version of the Containers class offers a new concept, namely shortcut, that allows not only to avoid the dependencies between parent-classes and their children classes, but also offers some additional advantages, remarkably improving the efficiency of components.Peer ReviewedPostprint (author's final draft

A quality model for the Ada standard container library

The existence of a standard container library has been largely recognized as a key feature for improving the quality and effectiveness of Ada programming. In this paper, we aim at providing a quality model for making explicit the quality features (those concerning functionality, suitability, etc.) that determine the form that such a library might take. Quality features are arranged hierarchically according to the ISO/IEC quality standard. We tailor this standard to the specific context of container libraries, by identifying their observable attributes and establishing some tradeoffs among them. Afterwards, we apply the resulting model to a pair of existing container libraries. As main contribution of our proposal, we may say that the resulting quality model provides a structured framework for (1) discussing and evaluating the capabilities that the prospective Ada Standard Container Library might offer, and (2) analyzing the consequences of the decisions taken during its design.Peer ReviewedPostprint (author's final draft

SALMon: A SOA system for monitoring service level agreements

In this paper we present SALMon, a tool assessing the satisfaction of service level agreement (SLA) clauses by service-oriented systems. SALMon itself is organized as a service-oriented system that offers two kind of services: 1) the Monitor service that measures the values in execution time of dynamic quality attributes (like response time or availability), and 2) the Analyzer service that detects and reports violations of SLA clauses from the values obtained with the Monitor. The SALMon tool is highly versatile, allowing: 1) both active testing and passive monitoring as strategies, 2) different types of technologies for the monitored/tested systems (e.g., Web services, RESTful services), 3) agile definition of measure instruments for new quality attributes. The service-oriented nature of SALMon makes it scalable and easy to integrate with other services that need its functionalities.Postprint (published version

Monitoring the service-based system lifecycle with SALMon

Los Sistemas Basados en Servicios (SBS) son sistemas software altamente dinámicos compuestos por un conjunto de servicios web provenientes de distintos, y posiblemente heterogéneos, proveedores. En contraste con otros sistemas software tradicionales, el comportamiento dinámico de los SBS requiere de información actualizada sobre la calidad de servicio (QoS) para poder actuar i administrar correctamente las actividades en las distintas fases del ciclo de vida de los SBS (p.e., selección de servicios, despliegue, evaluación de niveles de acuerdo de servicio –SLA–, y adaptación). [...] Para cubrir esta brecha de investigación, presentamos SALMon, una plataforma de monitorización de servicios versátil que provee información acerca de la QoS según la forma y enfoque adecuado para las distintas actividades del ciclo de vida.Peer ReviewedPostprint (published version

Algebraic definition of iStar2.0 models

iStar2.0 was delivered in 2016 with the intention of becoming a standard de facto for the i* community. It includes a lightweight definition of the language adorned with a metamodel (in the form of a UML class diagram) that is useful for most purposes. However, in some contexts, a more precise algebraic definition including a notion of satisfaction is needed. This paper presents such elements. First, an algebraic definition of iStar2.0. Then, some auxiliary operations. Last, the notion of satisfaction over i* models using first order logic. Satisfaction is still defined mainly in a syntactic form, relying upon the satisfaction of the individual intentional elements comprising the model.Peer ReviewedPostprint (published version